{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Lane-detection\n",
    "\n",
    "    参考尤达学城的课题LaneLines-P1-master and CarND-Advanced-Lane-Lines-master，\n",
    "    进行添加灭点特征和平滑器，提高检测稳定性和结果可靠性，结合相似性函数提高车道线匹配稳定性，\n",
    "    以下对代码进行说明，由于设计公司项目细节，只贴初版代码。\n",
    "    \n",
    "    \n",
    "    **Some OpenCV functions (beyond those introduced in the lesson) that might be useful for this project are:**\n",
    "    **Check out the OpenCV documentation to learn about these and discover even more awesome functionality!**\n",
    "    `cv2.inRange()` for color selection  \n",
    "    `cv2.fillPoly()` for regions selection  \n",
    "    `cv2.line()` to draw lines on an image given endpoints  \n",
    "    `cv2.addWeighted()` to coadd / overlay two images  \n",
    "    `cv2.cvtColor()` to grayscale or change color  \n",
    "    `cv2.imwrite()` to output images to file  \n",
    "    `cv2.bitwise_and()` to apply a mask to an image  "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import Packages"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "#importing some useful packages\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.image as mpimg\n",
    "import numpy as np\n",
    "import cv2\n",
    "import math as ma\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Some Useful Function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# SimularMeal，相似度度量函数，输入直线特征的斜率和与图像底边的交点x坐标值（类似点斜式），对比两直线区别（这里的系数需要调参）\n",
    "def SimularMea1(k1,ex1,k2,ex2):\n",
    "    delta_angle=abs(ma.atan(k1)-ma.atan(k2))*180/ma.pi\n",
    "    delta_b_y=abs((ex1-960)*k1-(ex2-960)*k2)#960 induce the width of input img\n",
    "    return delta_b_y/10 + delta_angle#value function1\n",
    "\n",
    "# 待定，\n",
    "def SimularMea2():\n",
    "    return None\n",
    "\n",
    "# getCrossPoint，函数用于求取两条直线的交点坐标，返回值为np.array([u,v])\n",
    "def getCrossPoint(LineA, LineB):\n",
    "    # calculate the k of line A/B\n",
    "    ka = (LineA[3] - LineA[1]) / (LineA[2] - LineA[0])\n",
    "    kb = (LineB[3] - LineB[1]) / (LineB[2] - LineB[0])\n",
    "\n",
    "    crossPoint=[0,0] # (x,y)\n",
    "    crossPoint[0] = (ka*LineA[0] - LineA[1] - kb*LineB[0] + LineB[1]) / (ka - kb)\n",
    "    crossPoint[1] = (ka*kb*(LineA[0] - LineB[0]) + ka*LineB[1] - kb*LineA[1]) / (ka - kb)\n",
    "    return np.array(crossPoint)\n",
    "\n",
    "# disPL2，求point到line的直线距离\n",
    "def disP2L(point,line):#line=[x1,x2,y1,y2]\n",
    "    X1=line[0]\n",
    "    Y1=line[1]\n",
    "    X2=line[2]\n",
    "    Y2=line[3]\n",
    "    \n",
    "    a=Y2-Y1\n",
    "    b=X1-X2\n",
    "    c=X2*Y1-X1*Y2\n",
    "    dis=(ma.fabs(a*point[0]+b*point[1]+c))/(ma.pow(a*a+b*b,0.5))\n",
    "    return dis\n",
    "\n",
    "# CatchVanishP，求取灭点，基于已知直线，求其交点，再基于交点，通过聚类筛选出灭点\n",
    "def CatchVanishP(lines,length):\n",
    "    Clusterpoint=[[getCrossPoint(lines[0],lines[1])]]\n",
    "    for i in range(0,length):\n",
    "        for j in range(i+1,length):\n",
    "            temppoint = getCrossPoint(lines[i],lines[j])\n",
    "            tempid=0\n",
    "            mindif=100\n",
    "            for k in range(len(Clusterpoint)):\n",
    "                temp=sum(abs(Clusterpoint[k][0]-temppoint))\n",
    "                if temp < mindif:\n",
    "                    mindif = temp\n",
    "                    tempid=k\n",
    "            if mindif==100:\n",
    "                Clusterpoint.append([getCrossPoint(lines[i],lines[j])])\n",
    "            else:\n",
    "                Clusterpoint[tempid].append(getCrossPoint(lines[i],lines[j]))\n",
    "    maxlen=0\n",
    "    for points in Clusterpoint:\n",
    "        lenth=len(points)\n",
    "        if lenth>maxlen:\n",
    "            maxlen=lenth\n",
    "            point=np.mean(points,axis=0)\n",
    "    return point"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 滚动平滑器，通过滚动平滑，不断更新记录的车道线，每条车道线保留window_size个数据，输出为平均值，\n",
    "# 使车道线显示平滑更新，结果更稳定，鲁棒性更高。\n",
    "class Smooth:\n",
    "    def __init__(self, windowsize=10):\n",
    "        # 初始化，window_size代表同一根车道线最多保留多少帧结果，实际输出为平均值！\n",
    "        # index记录帧数，lenth记录有效车道数，threshold需要调参，time记录每条车道线的检测数，VP记录灭点像素坐标\n",
    "        # data，保留window_size帧数据，最多10条车道线，每条车道线有4个参数\n",
    "        self.window_size = windowsize\n",
    "        self.data = np.zeros((self.window_size, 10, 4), dtype=np.float32)\n",
    "        self.index = 0\n",
    "        self.lenth = 0\n",
    "        self.threshold = 300\n",
    "        self.time = np.array([0,0,0,0,0,0,0,0,0,0],dtype=np.int8)\n",
    "        self.VP = None\n",
    "    \n",
    "    def __iadd__(self, x):# 对接重载的+=操作\n",
    "        if self.index == 0:\n",
    "\t\t# 初始化\n",
    "            self.lenth = len(x)\n",
    "            self.data[:,0:self.lenth] = x \n",
    "            self.time[0:self.lenth] = 2\n",
    "        index = self.index % self.window_size\n",
    "        \n",
    "        # 当帧车道线与跟踪数据对比，判断是否属于，是则加入data中作为更新值，否则丢弃数据或者作为新跟踪目标；当有灭点时，\n",
    "        # 判断是否经过灭点，去掉不经过的车道线；实时更新time值，>0为有效目标，否则无效；每3帧更新一次灭点和跟踪数目。\n",
    "        for data in x:\n",
    "            mindif = self.threshold\n",
    "            tempid = 0\n",
    "            for ID in range(self.lenth):\n",
    "                Data = self.data[index][ID]\n",
    "                temp = abs(data[0]-Data[0])# 另外构建SimularMea2代入\n",
    "                if temp < mindif:\n",
    "                    mindif = temp\n",
    "                    tempid = ID\n",
    "            if self.VP is not None:\n",
    "                if disP2L(self.VP,data)>15:# 灭点到线距离，大于阈值15，则认为不经过灭点，需要调参。\n",
    "                    continue                \n",
    "            # 若未检测到，则增设为新的跟踪车道线，否则作为某条车道线在平滑器中记录的当帧更新值\n",
    "            if mindif == self.threshold:\n",
    "                self.data[:,self.lenth] = data\n",
    "                self.time[self.lenth] = 3\n",
    "                self.lenth += 1\n",
    "            else:\n",
    "                self.data[index][tempid] = data\n",
    "                self.time[tempid] += 2\n",
    "        self.time[self.time>0] -=1\n",
    "\t\t\n",
    "\t\t# 每3帧，计算一次灭点，剔除无效车道线。\n",
    "        if self.index % 3 == 0:\n",
    "            targetid=np.nonzero(self.time)\n",
    "            templen=len(targetid[0])\n",
    "            \n",
    "            if templen != self.lenth:\n",
    "                temp=self.data[:,targetid,:].mean(axis=0)\n",
    "                self.data=np.zeros((self.window_size, 10, 4), dtype=np.float32)\n",
    "                self.data[:,0:templen,:] = temp\n",
    "                \n",
    "                temp=self.time[targetid]\n",
    "                self.time = np.array([0,0,0,0,0,0,0,0,0,0],dtype=np.int8)\n",
    "                self.time[0:templen]=temp\n",
    "            \n",
    "                self.lenth=templen\n",
    "\n",
    "            temp=self.data.mean(axis=0)\n",
    "            if self.lenth >2:\n",
    "                self.VP=CatchVanishP(temp,self.lenth)        \n",
    " \n",
    "        self.index += 1\n",
    "        return self"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def grayscale(img):\n",
    "    \"\"\"Applies the Grayscale transform  This will return an image with only one color channel\n",
    "    but NOTE: to see the returned image as grayscale you should call plt.imshow(gray, cmap='gray')    \"\"\"\n",
    "    return cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n",
    "    \n",
    "def canny(img, low_threshold, high_threshold):\n",
    "    \"\"\"Applies the Canny transform\"\"\"\n",
    "    return cv2.Canny(img, low_threshold, high_threshold)\n",
    "\n",
    "def gaussian_blur(img, kernel_size):\n",
    "    return cv2.GaussianBlur(img, (kernel_size, kernel_size), 0)\n",
    "\n",
    "def region_of_interest(img, vertices):\n",
    "    \"\"\" Applies an image mask. Only keeps the region of the image defined by the polygon formed from `vertices`. \n",
    "    The rest of the image is set to black. \"\"\"\n",
    "    #defining a blank mask to start with\n",
    "    mask = np.zeros_like(img)   \n",
    "    \n",
    "    #defining a 3 channel or 1 channel color to fill the mask with depending on the input image\n",
    "    if len(img.shape) > 2:\n",
    "        channel_count = img.shape[2]  # i.e. 3 or 4 depending on your image\n",
    "        ignore_mask_color = (255,) * channel_count\n",
    "    else:\n",
    "        ignore_mask_color = 255\n",
    "        \n",
    "    #filling pixels inside the polygon defined by \"vertices\" with the fill color    \n",
    "    cv2.fillPoly(mask, vertices, ignore_mask_color)\n",
    "    \n",
    "    #returning the image only where mask pixels are nonzero\n",
    "    masked_image = cv2.bitwise_and(img, mask)\n",
    "    return masked_image\n",
    "\n",
    "def draw_lines(img, lines, color=[255, 0, 0], thickness=2):\n",
    "    \"\"\" Draws `lines` with `color` and `thickness`. \"\"\"\n",
    "    for line in lines:\n",
    "        for x1,y1,x2,y2 in line:\n",
    "            cv2.line(img, (x1, y1), (x2, y2), color, thickness)\n",
    "\n",
    "def hough_lines(img, rho, theta, threshold, min_line_len, max_line_gap):\n",
    "    # 基于houghLinesP的结果进行特征处理，转化直线特征成斜截式，基于相似度函数对直线进行分类，\n",
    "    # 剔除数量过少的目标，把车道线均值传入平滑器\n",
    "    \n",
    "    # a为声明全局Smooth类，用法下文介绍\n",
    "    global a\n",
    "    \n",
    "    # 预处理后的图像传入houghlinesP,完成hough变换\n",
    "    lines = cv2.HoughLinesP(img, rho, theta, threshold, np.array([]), minLineLength=min_line_len, maxLineGap=max_line_gap)\n",
    "    line_img = np.zeros([img.shape[0], img.shape[1], 3], dtype=np.uint8)\n",
    "    lines2 = []\n",
    "    try:\n",
    "\t    # 遍历检测结果，根据k取值，筛选车道线结果\n",
    "        for line in lines:\n",
    "            for x1,y1,x2,y2 in line:\n",
    "                if abs(y1-y2) < 10:#10\n",
    "                    continue\n",
    "                k = float(y2-y1)/(x2-x1)\n",
    "                if abs(1/k)>5:\n",
    "                    continue\n",
    "                # 输出结果统一，转化为斜截式\n",
    "                if y1 > y2:\n",
    "                    extend = int(x2 + (height-y2)/k)\n",
    "                    lines2.append([x2-x1, y2, k, extend])\n",
    "                elif y1 < y2:\n",
    "                    extend = int(x1 + (height-y1)/k)\n",
    "                    lines2.append([x2-x1, y1, k, extend])\n",
    "        lines3 = [[lines2[0]]]\n",
    "        \n",
    "\t\t# 基于相似性函数，对车道线进行分类，把同一条车道线数据分成一类，这里需要调参mindif\n",
    "        for j in range(len(lines2)):\n",
    "            mindif=10\n",
    "            tempid=0\n",
    "            side=lines2[j]\n",
    "            for ID in range(len(lines3)):\n",
    "                temp = SimularMea1(lines3[ID][0][2],lines3[ID][0][3],side[2],side[3])# 相似度计算函数\n",
    "                if temp < mindif:\n",
    "                    mindif = temp\n",
    "                    tempid = ID    \n",
    "            if mindif > 7:\n",
    "                lines3.append([side])\n",
    "            else:\n",
    "                lines3[tempid].append(side)\n",
    "        \n",
    "        # 基于分类结果，取平均值，得到lines4，并把结果传输给smooth，这里对+=操作重载操作\n",
    "        lines4=[]\n",
    "        for side in lines3:\n",
    "            if len(side)<3:\n",
    "                continue\n",
    "            side=np.array(side)\n",
    "            h2 = side[:, 1].min()\n",
    "            side[:,0] /= side[:,0].min()\n",
    "            k1 = np.average(side[:,2], weights=side[:,0])\n",
    "            x1 = np.average(side[:,3], weights=side[:,0])\n",
    "            lines4.append([int(x1), height, int(x1-(height-h2)/k1), int(h2)])\n",
    "        a += np.array(lines4)\n",
    "    except:\n",
    "        pass\n",
    "    # 从smooth中取出平滑结果，作为当帧输出。\n",
    "    lines5 = a.data.mean(axis=0)\n",
    "    draw_lines(line_img, [lines5], thickness=5)\n",
    "    return line_img\n",
    "\n",
    "# Python 3 has support for cool math symbols.\n",
    "def weighted_img(img, initial_img, a=0.8, b=1., c=0.):\n",
    "    \"\"\" `img` is the output of the hough_lines(), An image with lines drawn on it.\n",
    "    Should be a blank image (all black) with lines drawn on it.\n",
    "    `initial_img` should be the image before any processing.\n",
    "    result = initial_img * α + img * β + λ\n",
    "    NOTE: initial_img and img must be the same shape!\n",
    "    \"\"\"\n",
    "    return cv2.addWeighted(initial_img, a, img, b, c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x1d918bd1710>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "a = Smooth()\n",
    "# image = cv2.imread('test_images/solidYellowCurve.jpg')\n",
    "image = cv2.imread('test_images/solidWhiteCurve.jpg')\n",
    "# image = cv2.imread('test_images/challenge.png')\n",
    "image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)\n",
    "height = image.shape[0]\n",
    "width = image.shape[1]\n",
    "interest = np.array([[0, height], [0,400], [width*3/8, height*5/9],\n",
    "                     [width*5/8, height*5/9], [width,height*0.6], [width, height]], np.int32)\n",
    "\n",
    "#canny\n",
    "gray = grayscale(image)\n",
    "blur_gray = gaussian_blur(gray,7)\n",
    "edges = canny(blur_gray, 65, 170)\n",
    "masked_edges = region_of_interest(edges,[interest])\n",
    "\n",
    "#  img, rho, theta, threshold, min_line_len, max_line_gap\n",
    "lines = hough_lines(masked_edges, 1, np.pi/180, 15, 1, 130)\n",
    "result = weighted_img(image, lines, 0.9, 0.9)\n",
    "\n",
    "def showimg(subplace, title, _img):\n",
    "    plt.subplot(*subplace)\n",
    "    plt.title(title)\n",
    "    if len(_img.shape) == 3:\n",
    "        plt.imshow(_img)\n",
    "    else:\n",
    "        plt.imshow(_img, cmap='gray')\n",
    "\n",
    "plt.figure(figsize=[16, 9])\n",
    "for i, imgname in enumerate(['image', 'gray', 'edges', 'masked_edges', 'lines', 'result']):\n",
    "    showimg((3, 3, i+1), imgname, eval(imgname))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test on Videos"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Import everything needed to edit/save/watch video clips\n",
    "from moviepy.editor import VideoFileClip\n",
    "from IPython.display import HTML"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_image(image):\n",
    "    # put your pipeline here,\n",
    "    # you should return the final output (image with lines are drawn on lanes)\n",
    "    \n",
    "    global height, width\n",
    "    height = image.shape[0]\n",
    "    width = image.shape[1]\n",
    "    interest = np.array([[0, height], [0,400], [width*3/8, height*5/9],\n",
    "                         [width*5/8, height*5/9], [width,height*0.6], [width, height]], np.int32)\n",
    "    gray = grayscale(image)\n",
    "    blur_gray = gaussian_blur(gray,7)\n",
    "    edges = canny(blur_gray, 65, 170)\n",
    "    masked_edges = region_of_interest(edges,[interest])\n",
    "\n",
    "    #  img, rho, theta, threshold, min_line_len, max_line_gap\n",
    "    lines = hough_lines(masked_edges, 1, np.pi/180, 15, 1, 130)\n",
    "    result = weighted_img(image, lines, 0.9, 0.9)\n",
    "    return result"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try the one with the solid white lane on the right first ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video test_videos_output/white.mp4.\n",
      "Moviepy - Writing video test_videos_output/white.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready test_videos_output/white.mp4\n",
      "Wall time: 2.95 s\n"
     ]
    }
   ],
   "source": [
    "a = Smooth(windowsize=5)\n",
    "white_output = 'test_videos_output/white.mp4'\n",
    "clip1 = VideoFileClip(\"test_videos/solidWhiteRight.mp4\")\n",
    "white_clip = clip1.fl_image(process_image)\n",
    "%time white_clip.write_videofile(white_output, audio=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"960\" height=\"540\" controls>\n",
       "  <source src=\"test_videos_output/white.mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(\"\"\"\n",
    "<video width=\"960\" height=\"540\" controls>\n",
    "  <source src=\"{0}\">\n",
    "</video>\n",
    "\"\"\".format(white_output))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Improve the draw_lines() function\n",
    "\n",
    "**At this point, if you were successful with making the pipeline and tuning parameters, you probably have the Hough line segments drawn onto the road, but what about identifying the full extent of the lane and marking it clearly as in the example video (P1_example.mp4)?  Think about defining a line to run the full length of the visible lane based on the line segments you identified with the Hough Transform. As mentioned previously, try to average and/or extrapolate the line segments you've detected to map out the full extent of the lane lines. You can see an example of the result you're going for in the video \"P1_example.mp4\".**\n",
    "\n",
    "**Go back and modify your draw_lines function accordingly and try re-running your pipeline. The new output should draw a single, solid line over the left lane line and a single, solid line over the right lane line. The lines should start from the bottom of the image and extend out to the top of the region of interest.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now for the one with the solid yellow lane on the left. This one's more tricky!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video test_videos_output/solidYellowLeft.mp4.\n",
      "Moviepy - Writing video test_videos_output/solidYellowLeft.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready test_videos_output/solidYellowLeft.mp4\n",
      "Wall time: 9.68 s\n"
     ]
    }
   ],
   "source": [
    "a = Smooth(windowsize=5)\n",
    "\n",
    "yellow_output = 'test_videos_output/solidYellowLeft.mp4'\n",
    "## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n",
    "## To do so add .subclip(start_second,end_second) to the end of the line below\n",
    "## Where start_second and end_second are integer values representing the start and end of the subclip\n",
    "## You may also uncomment the following line for a subclip of the first 5 seconds\n",
    "##clip2 = VideoFileClip('test_videos/solidYellowLeft.mp4').subclip(0,5)\n",
    "clip2 = VideoFileClip('test_videos/solidYellowLeft.mp4')\n",
    "yellow_clip = clip2.fl_image(process_image)\n",
    "%time yellow_clip.write_videofile(yellow_output, audio=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"960\" height=\"540\" controls>\n",
       "  <source src=\"test_videos_output/solidYellowLeft.mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(\"\"\"\n",
    "<video width=\"960\" height=\"540\" controls>\n",
    "  <source src=\"{0}\">\n",
    "</video>\n",
    "\"\"\".format(yellow_output))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "## Optional Challenge\n",
    "\n",
    "Try your lane finding pipeline on the video below.  Does it still work?  Can you figure out a way to make it more robust?  If you're up for the challenge, modify your pipeline so it works with this video and submit it along with the rest of your project!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def process_image(image):\n",
    "    #canny\n",
    "    gray = grayscale(image)\n",
    "    blur_gray = gaussian_noise(gray,7)\n",
    "    edges = canny(blur_gray, 50, 150)\n",
    "\n",
    "    # Next we'll create a masked edges image using cv2.fillPoly()\n",
    "    mask = np.zeros_like(edges)   \n",
    "    ignore_mask_color = 255   \n",
    "\n",
    "    # define the region-of-interest\n",
    "    imshape = image.shape\n",
    "    vertices = np.array([[(0,imshape[0]-70),(220, 400), (580, 400), (imshape[1],imshape[0]-70)]], dtype=np.int32)\n",
    "    masked_edges = region_of_interest(edges,vertices)\n",
    "\n",
    "    # Define the Hough transform parameters\n",
    "    rho = 1                             # distance resolution in pixels of the Hough grid\n",
    "    theta = np.pi/180                   # angular resolution in radians of the Hough grid\n",
    "    threshold = 100                     # minimum number of votes (intersections in Hough grid cell)\n",
    "    min_line_length = 20                 # minimum number of pixels making up a line\n",
    "    max_line_gap = 25                   # maximum gap in pixels between connectable line segments\n",
    "    line_image = np.copy(image)*0       # creating a blank to draw lines on\n",
    "\n",
    "    # Run Hough on edge detected image\n",
    "    line_image = hough_lines(masked_edges, rho, theta, threshold, min_line_length, max_line_gap)\n",
    "    \n",
    "    # Create the combined image, show and save it\n",
    "    color_edges = np.dstack((edges, edges, edges)) \n",
    "    finalimg = weighted_img(line_image,image)\n",
    "    return finalimg"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Building video test_videos_output/challenge.mp4.\n",
      "Moviepy - Writing video test_videos_output/challenge.mp4\n",
      "\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "                                                                                                                       \r"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Moviepy - Done !\n",
      "Moviepy - video ready test_videos_output/challenge.mp4\n",
      "Wall time: 8.07 s\n"
     ]
    }
   ],
   "source": [
    "a = Smooth(windowsize=5)\n",
    "\n",
    "challenge_output = 'test_videos_output/challenge.mp4'\n",
    "## To speed up the testing process you may want to try your pipeline on a shorter subclip of the video\n",
    "## To do so add .subclip(start_second,end_second) to the end of the line below\n",
    "## Where start_second and end_second are integer values representing the start and end of the subclip\n",
    "## You may also uncomment the following line for a subclip of the first 5 seconds\n",
    "##clip3 = VideoFileClip('test_videos/challenge.mp4').subclip(0,5)\n",
    "clip3 = VideoFileClip('test_videos/challenge.mp4')\n",
    "challenge_clip = clip3.fl_image(process_image)\n",
    "%time challenge_clip.write_videofile(challenge_output, audio=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "<video width=\"960\" height=\"540\" controls>\n",
       "  <source src=\"test_videos_output/challenge.mp4\">\n",
       "</video>\n"
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "HTML(\"\"\"\n",
    "<video width=\"960\" height=\"540\" controls>\n",
    "  <source src=\"{0}\">\n",
    "</video>\n",
    "\"\"\".format(challenge_output))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
